package tp.disenio.controllers;

import java.util.ArrayList;
import java.util.Vector;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import tp.disenio.client.CompetenciaDTO;
import tp.disenio.client.DisponibilidadDTO;
import tp.disenio.client.ResultadoDTO;
import tp.disenio.client.SetsDTO;
import tp.disenio.factory.JpaUtil;
import tp.disenio.shared.Competencia;
import tp.disenio.shared.Deporte;
import tp.disenio.shared.Disponibilidad;
import tp.disenio.shared.DisponibilidadPK;
import tp.disenio.shared.Estadodecompetencia;
import tp.disenio.shared.Fecha;
import tp.disenio.shared.Logresultado;
import tp.disenio.shared.Lugarderealizacion;
import tp.disenio.shared.Modalidad;
import tp.disenio.shared.Participante;
import tp.disenio.shared.Partido;
import tp.disenio.shared.Puntuacion;
import tp.disenio.shared.Reglamento;
import tp.disenio.shared.Resultado;
import tp.disenio.shared.Resultadofinal;
import tp.disenio.shared.Sets;
import tp.disenio.shared.Tabladeposiciones;
import tp.disenio.shared.Tipodepuntuacion;
import tp.disenio.shared.Usuario;
import ClasesDAO.CompetenciaDAO;
import ClasesDAO.DAO_General;
import ClasesDAO.LugarDeRealizacionDAO;
import ClasesDAO.UsuarioDAO;


/**
 * @author 
 * @version 1.0
 * @created 
 */
public class ControlCompetencia {

	
	// CU03 Listar Competencias Deportivas UA
	/**
	 * 
	 * @param id_usuario
	 * @param nombrgenerare
	 * @param deporte
	 * @param modalidad
	 * @param estado
	 */
	public static ArrayList<CompetenciaDTO> listarCompetencias(String usuarioMail, String nombreCompetencia, String deporte, String modalidad, String estado){
	
		ArrayList<CompetenciaDTO> competenciasDTO = new ArrayList<CompetenciaDTO>();
		ArrayList<Competencia> competencias = new ArrayList<Competencia>();
		int idUsuario = UsuarioDAO.getIdUsuarioPorMail(usuarioMail);
		
		competencias = CompetenciaDAO.filtrarCompetencias(idUsuario, nombreCompetencia, deporte, modalidad, estado);			
		
		
		for (int i = 0; i < competencias.size(); i++){
			
			Competencia competencia = competencias.get(i);
			CompetenciaDTO competenciaDTO = new CompetenciaDTO();
			
			competenciaDTO.setUsuario(usuarioMail);
			competenciaDTO.setNombre(competencia.getNombre());
			competenciaDTO.setDeporte(competencia.getDeporte().getNombre());
			competenciaDTO.setModalidad(competencia.getModalidad().getNombre());
			competenciaDTO.setEstadodecompetencia(competencia.getEstado().getNombre());
			
			competenciasDTO.add(competenciaDTO);
		}		
		
		return competenciasDTO;
	}
	
	
	// CUXX Listar Competencias Deportivas UNA
	/**
	 * 
	 * @param id_usuario
	 * @param nombre
	 * @param deporte
	 * @param modalidad
	 * @param estado
	 */
	public static ArrayList<CompetenciaDTO> listarCompetenciasUNA(String nombreCompetencia, String deporte, String modalidad, String estado){
	
		ArrayList<CompetenciaDTO> competenciasDTO = new ArrayList<CompetenciaDTO>();
		ArrayList<Competencia> competencias = CompetenciaDAO.filtrarCompetencias(nombreCompetencia, deporte, modalidad, estado);
		
		for (int i = 0; i < competencias.size(); i++){
			
			Competencia competencia = competencias.get(i);
			CompetenciaDTO competenciaDTO = new CompetenciaDTO();
			
			competenciaDTO.setUsuario(competencia.getUsuario().getCorreoElectronico());
			competenciaDTO.setNombre(competencia.getNombre());
			competenciaDTO.setDeporte(competencia.getDeporte().getNombre());
			competenciaDTO.setModalidad(competencia.getModalidad().getNombre());
			competenciaDTO.setEstadodecompetencia(competencia.getEstado().getNombre());
			
			competenciasDTO.add(competenciaDTO);
		}		
		
		return competenciasDTO;
	}
	
		
	// CU04
	/**
	 * 
	 * @param usuario2
	 * @param nombre
	 * @param n_deporte
	 * @param lugarRealizacion
	 * @param n_modalidad
	 * @param puntos_partido_ganado
	 * @param permitir_empates
	 * @param puntos_partido_empatado
	 * @param puntos_por_presentarse
	 * @param cantidad_sets
	 * @param tantos_por_ausencia
	 * @param n_tipo_de_puntuacion
	 * @param n_reg
	 */
	public static boolean crearCompetencia(String usuarioMail, String nombre, String n_deporte, ArrayList<DisponibilidadDTO> disponibilidades,
								 String n_modalidad, int puntos_partido_ganado, boolean permitir_empates, int puntos_partido_empatado,
								 int puntos_por_presentarse, int cantidad_sets, int tantos_por_ausencia, String n_tipo_de_puntuacion, String n_reg)
									throws IllegalArgumentException{
		
		int idUsuario = UsuarioDAO.getIdUsuarioPorMail(usuarioMail);
		
		if (CompetenciaDAO.existeCompetencia(idUsuario, nombre)){			
			throw new IllegalArgumentException("El nombre indicado para la competencia ya fue registrado");				
		}
		
		else {
			Usuario usuario = UsuarioDAO.getUsuarioPorID(idUsuario);
			Deporte deporte = DAO_General.getDeportePorNombre(n_deporte);
			Estadodecompetencia estado = DAO_General.getEstadoPorNombre("Creada");
			Modalidad modalidad = DAO_General.getModalidadPorNombre(n_modalidad);
			Tipodepuntuacion tipoDePuntuacion = DAO_General.getTipoDePuntuacionPorNombre(n_tipo_de_puntuacion);
			Reglamento reglamento = new Reglamento();
			reglamento.setDescripcion(n_reg);
			
			Competencia competencia = new Competencia(usuario, nombre, estado, deporte, modalidad, puntos_partido_ganado,
													  permitir_empates, puntos_partido_empatado, puntos_por_presentarse, cantidad_sets,
													  tantos_por_ausencia, tipoDePuntuacion, reglamento);
				

				
			usuario.agregarCompetencia(competencia);				
			CompetenciaDAO.guardarCompetencia(competencia);	
			
			competencia.setIdCompetencia(CompetenciaDAO.getIDCompetenciaPorNombre(idUsuario, nombre));
			competencia.setDisponibilidades(new ArrayList<Disponibilidad>());			
			
			for (int i = 0; i < disponibilidades.size(); i++){
			String nombreLugarR = disponibilidades.get(i).getLugarDeRealizacion();
			Lugarderealizacion lugarDeRealizacion = LugarDeRealizacionDAO.getLugarDeRealizacionPorNombre(nombreLugarR);
			int cantidad = disponibilidades.get(i).getCantidad();									
			Disponibilidad disponibilidad = new Disponibilidad();
			disponibilidad.setIdDisponibilidad(new DisponibilidadPK(competencia.getIdCompetencia(), lugarDeRealizacion.getIdLugarDeRealizacion()));
			disponibilidad.setLugarderealizacion(lugarDeRealizacion);
			disponibilidad.setCantidad(cantidad);
			competencia.agregarDisponibilidad(disponibilidad);
		    }
			
			CompetenciaDAO.guardarDisponibilidad(competencia);
			
			return true;
		}
	}	
	
	
	// CU05
	/**
	 * 
	 * @param idUsuario
	 * @param id_competencia
	 * @param nombre
	 * @param n_deporte
	 * @param n_lugares_realizacion
	 * @param n_modalidad
	 * @param puntos_partido_ganado
	 * @param permitir_empates
	 * @param puntos_partido_empatado
	 * @param puntos_por_presentarse
	 * @param cantidad_sets
	 * @param tantos_por_ausencia
	 * @param n_tipo_de_puntuacion
	 * @param n_reg
	 */
	public static void modificarCompetencia(int idUsuario, int id_competencia,  String nombre, String n_deporte, ArrayList<DisponibilidadDTO> disponibilidades,
								 String n_modalidad, int puntos_partido_ganado, boolean permitir_empates, int puntos_partido_empatado,
								 int puntos_por_presentarse, int cantidad_sets, int tantos_por_ausencia, String n_tipo_de_puntuacion, String n_reg){
		
		if (CompetenciaDAO.existeCompetencia(idUsuario, nombre)){			
			throw new IllegalArgumentException("El nombre indicado para la competencia ya fue registrado");				
		}
		
		else {
				Usuario usuario = UsuarioDAO.getUsuarioPorID(idUsuario);
				Competencia competencia = CompetenciaDAO.getCompetenciaPorID(id_competencia);
				Deporte deporte = DAO_General.getDeportePorNombre(n_deporte);
				Estadodecompetencia estado = DAO_General.getEstadoPorNombre("Creada");
				Modalidad modalidad = DAO_General.getModalidadPorNombre(n_modalidad);
				Tipodepuntuacion tipoDePuntuacion = DAO_General.getTipoDePuntuacionPorNombre(n_tipo_de_puntuacion);
				Reglamento reglamento = new Reglamento();
				reglamento.setDescripcion(n_reg);
				
				competencia.actualizarCompetencia(usuario, nombre, estado, deporte, modalidad, puntos_partido_ganado,
														  permitir_empates, puntos_partido_empatado, puntos_por_presentarse, cantidad_sets,
														  tantos_por_ausencia, tipoDePuntuacion, reglamento);
				
				
				
				
				usuario.agregarCompetencia(competencia);				
				CompetenciaDAO.guardarCompetencia(competencia);
				
				CompetenciaDAO.vaciarDisponibilidades(id_competencia);
				competencia.setIdCompetencia(CompetenciaDAO.getIDCompetenciaPorNombre(idUsuario, nombre));
				competencia.setDisponibilidades(new ArrayList<Disponibilidad>());			
				
				for (int i = 0; i < disponibilidades.size(); i++){
				String nombreLugarR = disponibilidades.get(i).getLugarDeRealizacion();
				Lugarderealizacion lugarDeRealizacion = LugarDeRealizacionDAO.getLugarDeRealizacionPorNombre(nombreLugarR);
				int cantidad = disponibilidades.get(i).getCantidad();									
				Disponibilidad disponibilidad = new Disponibilidad();
				disponibilidad.setIdDisponibilidad(new DisponibilidadPK(competencia.getIdCompetencia(), lugarDeRealizacion.getIdLugarDeRealizacion()));
				disponibilidad.setLugarderealizacion(lugarDeRealizacion);
				disponibilidad.setCantidad(cantidad);
				competencia.agregarDisponibilidad(disponibilidad);
			    }
				
				CompetenciaDAO.guardarDisponibilidad(competencia);
		}		
	}
		
	
	// CU17
	/**
	 * 
	 * @param competenciaDTO
	 */
	public static boolean generarFixture(CompetenciaDTO competenciaDTO)throws IllegalArgumentException{
		
		boolean banderaDummie = false;
		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
		int id_competencia = competencia.getIdCompetencia();
		
		String tipoPuntuacion = competencia.getTipoDePuntuacion().getNombre();
		
		int numeroParticipante1;
		int numeroParticipante2;
			
		ArrayList<Participante> listadoParticipantes = DAO_General.getParticipantes(id_competencia);
				
		if(listadoParticipantes.size()<=2){
			throw new IllegalArgumentException("La cantidad de participantes debe ser mayor a 2 para poder crear un fixture");
		}
		
		else{
						
			if (competencia.estaCreada() || competencia.estaPlanificada()){
									
				if (competencia.esLiga()){
					
					if(getCantidadDeFechas(competenciaDTO)>0){
					
						CompetenciaDAO.vaciarFechas(competencia.getIdCompetencia());
										
					}
					
					
					ArrayList<Participante> listaParticipantes = DAO_General.getParticipantes(competencia.getIdCompetencia());
					
					int cantidadParticipantes = listaParticipantes.size();
						
					
					if(!((cantidadParticipantes%2)==0)){ //Si no es par.
						
						banderaDummie = true;
						ControlParticipante.crearParticipante(competenciaDTO, "DummieLibre", "@.com");
						listaParticipantes =  DAO_General.getParticipantes(competencia.getIdCompetencia());
					
						cantidadParticipantes++;
					}
					
					ArrayList<ArrayList<String>> fechas = generarCombinacionesFixture(cantidadParticipantes); 
						
					for(int i=0;i<fechas.size();i++){ //Generando Fechas
				
						Fecha fechaNueva = new Fecha();
	//					fechaNueva.setIdFecha(DAO_General.getNuevoIdFecha());
						fechaNueva.setCompetencia(competencia);					
						fechaNueva.setIdCompetencia(competencia.getIdCompetencia());
						CompetenciaDAO.guardarFecha(fechaNueva);
						competencia.agregarFecha(fechaNueva);
					}
					
					//Obteniendo fechas
									
					ArrayList<Fecha> listaDeFechas = getFechas(competencia.getIdCompetencia());
															
					for(int i=0;i<fechas.size();i++){
							
						for(int j=0;j<fechas.get(i).size();j++){
							
							numeroParticipante1 = getNumero(fechas.get(i).get(j),1);
							numeroParticipante2 = getNumero(fechas.get(i).get(j),2);
																						
							if(!(listaParticipantes.get(numeroParticipante1-1).getNombre().equals("DummieLibre") ||
							     listaParticipantes.get(numeroParticipante2-1).getNombre().equals("DummieLibre"))){
												
							java.util.Date today = new java.util.Date();
							java.sql.Date dia = new java.sql.Date(604800000 + (86400000*(i%7)) + today.getTime()); 						
												
							String hora = (15+j)+":00";
							
							Partido partidoNuevo = new Partido();
							
							partidoNuevo.setFecha(dia);
							partidoNuevo.setHora(hora);
							partidoNuevo.setFechaBean(listaDeFechas.get(i));
							partidoNuevo.setIdFecha(listaDeFechas.get(i).getIdFecha());
																				
							listaDeFechas.get(i).agregarPartido(partidoNuevo);
							
							partidoNuevo.setParticipanteUNO(listaParticipantes.get(numeroParticipante1-1).getIdParticipante());
							partidoNuevo.setParticipanteDOS(listaParticipantes.get(numeroParticipante2-1).getIdParticipante());
										
							Resultado resultadoNuevo = new Resultado();
							resultadoNuevo.setAuxiliar("Auxiliar");
							
							resultadoNuevo.setPartido(partidoNuevo);
							partidoNuevo.setResultado(resultadoNuevo);
																	
							if(tipoPuntuacion.equals("Puntuacion")){
							
								Puntuacion resultadoPuntuacion = new Puntuacion();
							
								resultadoNuevo.setPuntuacion(resultadoPuntuacion);
														
								resultadoPuntuacion.setResultado(resultadoNuevo);
									resultadoPuntuacion.setValorLocal(-1);
									resultadoPuntuacion.setValorVisitante(-1);
																		
							}
							else if(tipoPuntuacion.equals("Sets")){
								
								int cantidadDeSets = competencia.getCantidadDeSets();
															
								Vector a = new Vector();
								
								for(int cantSets=0;cantSets <cantidadDeSets;cantSets++){
									
								
									Sets setNuevo = new Sets();
									
									
									setNuevo.setResultado(resultadoNuevo);
										setNuevo.setValorLocal(-1);
										setNuevo.setValorVisitante(-1);
																
									a.add(setNuevo);
								}
							
								resultadoNuevo.setSets(a);
											
							}
							else if(tipoPuntuacion.equals("Resultado Final")){
								
								Resultadofinal resultadoFinal = new Resultadofinal();
							
								resultadoNuevo.setResultadofinal(resultadoFinal);
								
								resultadoFinal.setResultado(resultadoNuevo);
									resultadoFinal.setCondicion("NoResultado");
													
								
							}
									
							ControlLugaresDeRealizacion.asignarLugarDeRealizacion(competencia,partidoNuevo);	
							DAO_General.guardarPartido(partidoNuevo);
							
							}
							
						}
									
					}
					
					if( banderaDummie ){
					ControlParticipante.eliminarParticipante("DummieLibre");
					}
														
					CompetenciaDAO.setEstado(id_competencia,"Planificada");
								
					return true;
				}
				
				else if (competencia.esEliminatoriaSimple()){				
					throw new IllegalArgumentException("Generar Fixture para Eliminatoria Simple aun no desarrollado, disculpe las molestias.");				
				}
				
				else if (competencia.esEliminatoriaDoble()){				
					throw new IllegalArgumentException("Generar Fixture para Eliminatoria Doble aun no desarrollado, disculpe las molestias.");				
				}			
			}
			
			else {			
				throw new IllegalArgumentException("La competencia no se encuentra en el estado Creada o Planificada, por lo que no se puede generar un nuevo fixture.");				
			}	
		
		}
		
		return false;
		
	}
	
	public static int getCantidadSets(CompetenciaDTO competencia){
		
		int id_usuario = UsuarioDAO.getIdUsuarioPorMail(competencia.getUsuario());
		Competencia competencia2 = CompetenciaDAO.getCompetenciaPorNombre(id_usuario, competencia.getNombre());
		
		return competencia2.getCantidadDeSets();
		
	}
	public static boolean cargarResultado(CompetenciaDTO competenciaDTO, ResultadoDTO resultadoDTO){

		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
		boolean retorno =  false;

		String tipoDePuntuacion = competencia.getTipoDePuntuacion().getNombre();
		
		if(tipoDePuntuacion.equals("Puntuacion")){
			
			retorno = cargarResultadoPuntuacion(competenciaDTO, resultadoDTO);
		}
		else if(tipoDePuntuacion.equals("Resultado Final")){
			
			retorno = cargarResultadoFinal(competenciaDTO, resultadoDTO);
		}
		else if(tipoDePuntuacion.equals("Sets")){
			
			retorno = cargarResultadoSets(competenciaDTO, resultadoDTO);
		}
		
		return retorno;
	}
	// CU18-A
	/**
	 * 
	 * @param competenciaDTO
	 * @param resultadoDTO
	 * @param puntuacion
	 * @return
	 */
	public static boolean cargarResultadoPuntuacion(CompetenciaDTO competenciaDTO, ResultadoDTO resultadoDTO){
					
		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
		int id_competencia = competencia.getIdCompetencia();
		
		if (validarCargaDePartido(competencia,resultadoDTO)){
		
			Partido partido = DAO_General.getPartidoPorParticipantes(id_competencia, resultadoDTO.getNombreLocal(), resultadoDTO.getNombreVisitante());
							
			if (competencia.esLiga()){
							
				Resultado resultado = CompetenciaDAO.getResultado(partido.getResultado().getIdResultado());
				
				Puntuacion puntuacion = resultado.getPuntuacion();		
														
				if((puntuacion.getValorLocal() != -1) || (puntuacion.getValorVisitante() != -1)){
				
					Logresultado logresultado = new Logresultado();
					logresultado.setPartido(partido);
					logresultado.setResultado(resultado);
					
					java.util.Date today = new java.util.Date();
					java.sql.Date dia = new java.sql.Date(604800000 + today.getTime()); 
					
					logresultado.setFechaModificacion(today);
					logresultado.setHoraModificacion((today.getHours()+1)+":"+today.getMinutes());
					
					DAO_General.guardarLogResultado(logresultado);
					
					Resultado resultadoNuevo = new Resultado();
					resultadoNuevo.setAuxiliar("Auxiliar");
											
					Puntuacion resultadoPuntuacion = new Puntuacion();
					
					resultadoNuevo.setPuntuacion(resultadoPuntuacion);
					resultadoPuntuacion.setResultado(resultadoNuevo);
				
					DAO_General.guardarResultado(resultadoNuevo);
					
					partido.setResultado(resultadoNuevo);
					resultadoNuevo.setPartido(partido);
					
					puntuacion = resultadoNuevo.getPuntuacion();
					
					DAO_General.actualizarPuntuacion(puntuacion);
					DAO_General.actualizarResultado(resultado);
				}
				
				if(resultadoDTO.getResultadoLocal().equals("No se presento")){
					
						puntuacion.setValorLocal(0);
						puntuacion.setValorVisitante(competencia.getTantosPorAusencia());
									
				}
				else if(resultadoDTO.getResultadoVisitante().equals("No se presento")){
										
						puntuacion.setValorLocal(competencia.getTantosPorAusencia());
						puntuacion.setValorVisitante(0);
					
				}
				else{
						
						puntuacion.setValorLocal(Integer.parseInt(resultadoDTO.getResultadoLocal()));
						puntuacion.setValorVisitante(Integer.parseInt(resultadoDTO.getResultadoVisitante()));
					
				}
				
				DAO_General.actualizarPuntuacion(puntuacion);
				DAO_General.actualizarResultado(resultado);
				DAO_General.actualizarPartido(partido);
			
			}
				
			else if (competencia.esEliminatoriaSimple()){					
					throw new IllegalArgumentException("Cargar Resultados para Eliminatoria Simple aun no desarrollado");		
						
			}
			
			else if (competencia.esEliminatoriaDoble()){					
					throw new IllegalArgumentException("Cargar Resultados para Eliminatoria Doble aun no desarrollado");		
								
			}				
				
		
		if(competencia.getEstado().getNombre().equals("Planificada")){
						
			CompetenciaDAO.setEstado(id_competencia,"En Ejecucion");
									
		}
		
		return true;
		
		}
		
		else {			
			throw new IllegalArgumentException("No es posible cargar resultados para este partido");			
		}		
	}


	// CU18-B
	/**
	 * 
	 * @param competenciaDTO
	 * @param resultadoDTO
	 * @param puntuacion
	 * @return
	 */
	public static boolean cargarResultadoFinal(CompetenciaDTO competenciaDTO, ResultadoDTO resultadoDTO) throws IllegalArgumentException{
		
		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
		int id_competencia = competencia.getIdCompetencia();		
		boolean retorno = false,continuar = true;
		
		if(resultadoDTO.getResultadoFinal().equals("Empate")){
			
			if(!competencia.getPermitirEmpates()){
			
			continuar = false;
			retorno = false;
		
			}
		}
		
		if(continuar){
						
			Partido partido = DAO_General.getPartidoPorParticipantes(id_competencia, resultadoDTO.getNombreLocal(), resultadoDTO.getNombreVisitante());
			Resultado resultado = partido.getResultado();
			Resultadofinal resultadoFinal = resultado.getResultadofinal();
			
			if(	   	resultadoFinal.getCondicion().equals("Local") 
				||  resultadoFinal.getCondicion().equals("Empate")
				||  resultadoFinal.getCondicion().equals("Visitante")){
				
				Logresultado logresultado = new Logresultado();
				logresultado.setPartido(partido);
				logresultado.setResultado(resultado);
				
				java.util.Date today = new java.util.Date();
				java.sql.Date dia = new java.sql.Date(604800000 + today.getTime()); 
				
				logresultado.setFechaModificacion(today);
				logresultado.setHoraModificacion((today.getHours()+1)+":"+today.getMinutes());
				
				DAO_General.guardarLogResultado(logresultado);
				
				Resultado resultadoNuevo = new Resultado();
				resultadoNuevo.setAuxiliar("Auxiliar");
			
				Resultadofinal resultadoFinal2 = new Resultadofinal();
				resultadoFinal2.setCondicion(resultadoDTO.getResultadoFinal());
				
				resultadoNuevo.setResultadofinal(resultadoFinal2);
				resultadoFinal2.setResultado(resultadoNuevo);

				DAO_General.guardarResultado(resultadoNuevo);
				
				partido.setResultado(resultadoNuevo);
				resultadoNuevo.setPartido(partido);
								
				resultadoFinal = resultadoFinal2;
				
				DAO_General.actualizarResultadoFinal(resultadoFinal);
				DAO_General.actualizarResultado(resultado);
					
			}
					
				resultadoFinal.setCondicion(resultadoDTO.getResultadoFinal());
					
				DAO_General.actualizarResultadoFinal(resultadoFinal);
				DAO_General.actualizarResultado(resultado);
				DAO_General.actualizarPartido(partido);
							
			if(competencia.getEstado().getNombre().equals("Planificada")){
				
				CompetenciaDAO.setEstado(id_competencia,"En Ejecucion");
				
			}
		
			retorno = true;
		}
		
		else{
			
			throw new IllegalArgumentException("La competencia no permite empates");
			
		}
			
		return retorno;
				
	}
	
	
	// CU18-C
	/**
	 * 
	 * @param competenciaDTO	
	 * @param resultadoDTO
	 * @param puntuacion
	 * @return
	 */
	public static boolean cargarResultadoSets(CompetenciaDTO competenciaDTO, ResultadoDTO resultadoDTO){
		
		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
		int id_competencia = competencia.getIdCompetencia();
				
		Partido partido = DAO_General.getPartidoPorParticipantes(id_competencia, resultadoDTO.getNombreLocal(), resultadoDTO.getNombreVisitante());	
		Resultado resultado =  partido.getResultado();
				
		if(!(((Sets)resultado.getSets().get(0)).getValorUno()<0)){
		
			Logresultado logresultado = new Logresultado();
			logresultado.setPartido(partido);
			logresultado.setResultado(resultado);
			
			java.util.Date today = new java.util.Date();
			java.sql.Date dia = new java.sql.Date(604800000 + today.getTime()); 
			
			logresultado.setFechaModificacion(today);
			logresultado.setHoraModificacion((today.getHours()+1)+":"+today.getMinutes());
			
			DAO_General.guardarLogResultado(logresultado);
			
			Resultado resultadoNuevo = new Resultado();
			resultadoNuevo.setAuxiliar("Auxiliar");
			
			int cantidadDeSets = competencia.getCantidadDeSets();
										
			Vector a = new Vector();
	
			for(int cantSets=0;cantSets <cantidadDeSets;cantSets++){
								
				Sets setNuevo = new Sets();
							
				setNuevo.setResultado(resultadoNuevo);
					setNuevo.setValorLocal(resultadoDTO.getSets().get(cantSets).getValorLocal());
					setNuevo.setValorVisitante(resultadoDTO.getSets().get(cantSets).getValorVisitante());
				
				DAO_General.actualizarSets(resultado.getSets().get(cantSets));
				a.add(setNuevo);
			}
		
			resultadoNuevo.setSets(a);
			
			DAO_General.guardarResultado(resultadoNuevo);
				
			partido.setResultado(resultadoNuevo);
			resultadoNuevo.setPartido(partido);
		
			resultado = resultadoNuevo;
			
			DAO_General.actualizarResultado(resultadoNuevo);	
			
		}
								
		for(int i=0;i<resultado.getSets().size();i++){
			
			resultado.getSets().get(i).setValorLocal(resultadoDTO.getSets().get(i).getValorLocal());
			resultado.getSets().get(i).setValorVisitante(resultadoDTO.getSets().get(i).getValorVisitante());
			DAO_General.actualizarSets(resultado.getSets().get(i));
					
		}
		
		if(competencia.getEstado().getNombre().equals("Planificada")){
			
			CompetenciaDAO.setEstado(id_competencia,"En Ejecucion");
			
		}
		
		DAO_General.actualizarResultado(resultado);
		DAO_General.actualizarPartido(partido);
		
		return true;
		
	}
		
		
	// CU20
	/**
	 * 
	 * @param id_competencia
	 * @return
	 */
	public static Competencia verCompetencia(int id_competencia){
		
		Competencia competencia = CompetenciaDAO.getCompetenciaPorID(id_competencia);		
		Estadodecompetencia estado = competencia.getEstado();
		
		java.util.Date today = new java.util.Date();
		java.sql.Date fechaActual = new java.sql.Date(today.getTime());
		
		if ((estado.getNombre() == "Planificada") || (estado.getNombre() == "En Ejecucion")){			
			competencia.getProximasFechas(fechaActual);	
		}
		
		return competencia;		
	}
	
	
	// CU21
	/**
	 * 
	 * @param idCompetencia
	 * @return
	 */
	public static Tabladeposiciones verTabladeposicioness(int idCompetencia){
		
		Competencia competencia = CompetenciaDAO.getCompetenciaPorID(idCompetencia);
		
		if (competencia.getModalidad().getNombre() == "Liga"){
			
			Estadodecompetencia estado = competencia.getEstado();
			if ((estado.getNombre() == "En Ejecucion") || (estado.getNombre() == "Finalizada")){				
				competencia.cargarTablaDePosiciones();
				
				return competencia.getTablaDePosiciones();				
			}		
			
			else {
				throw new IllegalArgumentException("Imposible cargar Tabla de Posiciones, la competencia aun no ha iniciado");
			}			
		}
		
		else {			
			throw new IllegalArgumentException("Imposible cargar Tabla de Posiciones, la competencia no es de la modalidad Liga");
		}
	}
	
	
	
	/**
	 * 
	 * @param competenciaDTO
	 * @param fechaNumero
	 * @return
	 */
	public static ArrayList<ResultadoDTO> getFecha(CompetenciaDTO competenciaDTO, int fechaNumero){
		
		EntityManagerFactory factory = Persistence.createEntityManagerFactory("auslober",System.getProperties());
		EntityManager em = factory.createEntityManager();
	
		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
	
		ArrayList<Fecha> listaDeFechas = CompetenciaDAO.getFechas(competencia.getIdCompetencia());
	
		Fecha fecha = listaDeFechas.get(fechaNumero);
	
		ArrayList<Partido> listaDePartidos = CompetenciaDAO.getPartidosFecha(fecha.getIdFecha());
			
		ArrayList<ResultadoDTO> listaResultado = new ArrayList<ResultadoDTO>();
				
		String tipoDePuntuacion = competencia.getTipoDePuntuacion().getNombre();
		
		if (tipoDePuntuacion.equals("Puntuacion")){
			
			for (int i = 0; i < listaDePartidos.size(); i++){
				
				Partido partido = listaDePartidos.get(i);
				Resultado resultado = partido.getResultado();
				ResultadoDTO resultadoDTO = new ResultadoDTO();
//				
//				String lugarHorario = "Lugar de realizacion: " + partido.getLugarderealizacion().getNombre() + " --- Horario: "+partido.getHora();
//				resultadoDTO.setLugarHorario(lugarHorario);
								
				Query query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante1.idParticipante");
				Participante participante1 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreLocal(participante1.getNombre());
			
				query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante2.idParticipante");
				Participante participante2 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreVisitante(participante2.getNombre());
				
				System.out.println(resultado.getPuntuacion().getIdPuntuacion());
				
				
				if(resultado.getPuntuacion().getValorUno()<0){
					resultadoDTO.setResultadoLocal("-");
				}
				else{
					resultadoDTO.setResultadoLocal(resultado.getPuntuacion().getValorUno()+"");
				}
			
				if(resultado.getPuntuacion().getValorDos()<0){
					resultadoDTO.setResultadoVisitante("-");
				}
				else{
					resultadoDTO.setResultadoVisitante(resultado.getPuntuacion().getValorDos()+"");
				}
				
				listaResultado.add(resultadoDTO);
				
			}
		}
		
		else if (tipoDePuntuacion.equals("Resultado Final")){
			
			for (int i = 0; i < listaDePartidos.size(); i++){
				
				Partido partido = listaDePartidos.get(i);
				Resultado resultado = partido.getResultado();
				ResultadoDTO resultadoDTO = new ResultadoDTO();
				
//				String lugarHorario = "Lugar de realizacion: " + partido.getLugarderealizacion().getNombre() + " --- Horario: "+partido.getHora();
//				resultadoDTO.setLugarHorario(lugarHorario);
				
				Query query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante1.idParticipante");
				Participante participante1 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreLocal(participante1.getNombre());
			
				query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante2.idParticipante");
				Participante participante2 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreVisitante(participante2.getNombre());
				
				
				if(resultado.getResultadofinal().getCondicion().equals("Local")){
					
					resultadoDTO.setResultadoLocal("Ganador");
					resultadoDTO.setResultadoVisitante("-");
											
				}
				else if(resultado.getResultadofinal().getCondicion().equals("Visitante")){
					
					resultadoDTO.setResultadoLocal("-");
					resultadoDTO.setResultadoVisitante("Ganador");
					
				}
				else if(resultado.getResultadofinal().getCondicion().equals("Empate")){
					
					resultadoDTO.setResultadoLocal("Empate");
					resultadoDTO.setResultadoVisitante("Empate");
					
				}
				else{
					
					resultadoDTO.setResultadoLocal("-");
					resultadoDTO.setResultadoVisitante("-");
					
				}
								
				listaResultado.add(resultadoDTO);
				
			}

		}
		
		else  if (tipoDePuntuacion.equals("Sets")){
			
			for (int i = 0; i < listaDePartidos.size(); i++){
				
				Partido partido = listaDePartidos.get(i);
				Resultado resultado = partido.getResultado();
				ArrayList<Sets> sets = resultado.getSets();
				
				ResultadoDTO resultadoDTO = new ResultadoDTO();			
				ArrayList<SetsDTO> setsDTO = new ArrayList<SetsDTO>(); 
				
//				String lugarHorario = "Lugar de realizacion: " + partido.getLugarderealizacion().getNombre() + " --- Horario: "+partido.getHora();
//				resultadoDTO.setLugarHorario(lugarHorario);
				
				Query query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante1.idParticipante");
				Participante participante1 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreLocal(participante1.getNombre());
			
				query = em.createQuery("SELECT PA FROM Partido P, Participante PA WHERE P.idFecha = " + fecha.getIdFecha() + " AND " + "P.idPartido = "+listaDePartidos.get(i).getIdPartido() +  " AND " + "PA.idParticipante = P.participante2.idParticipante");
				Participante participante2 = (Participante)query.getSingleResult();
				
				resultadoDTO.setNombreVisitante(participante2.getNombre());
				
				for (int j = 0; j < sets.size(); j++){
					Sets set = sets.get(j);
					SetsDTO setDTO = new SetsDTO(set.getValorLocal(), set.getValorVisitante());
					setsDTO.add(setDTO);
				}
				
				resultadoDTO.setSets(setsDTO);
				
				String ganador  = detectarGanador(resultadoDTO);
				
				if(ganador.equals("Local")){
					
					resultadoDTO.setResultadoLocal("Ganador");
					resultadoDTO.setResultadoVisitante("-");
					
				}
				else if(ganador.equals("Visitante")){
				
					resultadoDTO.setResultadoLocal("-");
					resultadoDTO.setResultadoVisitante("Ganador");
					
				}
				else{
					
					resultadoDTO.setResultadoLocal("-");
					resultadoDTO.setResultadoVisitante("-");
					
				}
								
				listaResultado.add(resultadoDTO);
			}		
		}				
		
		return listaResultado;
	}
	
	
	/**
	 * 
	 * @param competencia
	 * @return
	 */
	public static int getCantidadDeFechas(CompetenciaDTO competenciaDTO){
			
		return CompetenciaDAO.getCantidadDeFechas(competenciaDTO);
			
		
	}


//	/**
//	 * 
//	 * @param competenciaDTO
//	 * @param fechaNumero
//	 * @return
//	 */
//	public static ArrayList<PosicionesLigaDTO> getFechaPosiciones(CompetenciaDTO competenciaDTO, int fechaNumero) {
//		
////		int id_usuario = UsuarioDAO.getIdUsuarioPorMail(competenciaDTO.getUsuario());
////		Competencia competencia = CompetenciaDAO.getCompetenciaPorNombre(id_usuario, competenciaDTO.getNombre());
////		competencia.cargarTabladeposicioness();
////		ArrayList<RenglonTablaPosiciones> renglones = (ArrayList<RenglonTablaPosiciones>) competencia.getTabladeposicioness().getRenglonesTabla();
//		ArrayList<PosicionesLigaDTO> listaRetorno = new ArrayList<PosicionesLigaDTO>();
////		
////		for (int i = 0; i < renglones.size(); i++){
////			
////			RenglonTablaPosiciones renglon = renglones.get(i);
////			PosicionesLigaDTO posicion = new PosicionesLigaDTO();
////			
////			posicion.setEquipo(renglon.getNombreParticipante());
////			posicion.setPuntos(renglon.getPuntaje());
////			posicion.setGolesFavor(renglon.getTantosAFavor());
////			posicion.setGolesContra(renglon.getTantosEnContra());
////			posicion.setDiferenciaDeGoles(renglon.getDiferenciaDeGoles());
////			posicion.setPartidosJugados(renglon.getPartidosJugados());
////			posicion.setPartidosGanados(renglon.getPartidosGanados());
////			posicion.setPartidosEmpatados(renglon.getPartidosEmpatados());
////			posicion.setPartidosPerdidos(renglon.getPartidosPerdidos());		
////		}		
//				
//		
//		return listaRetorno;
//	}
	
	
	/**
	 * 
	 * @param id_competencia
	 * @param id_partido
	 * @return
	 */
	private static boolean validarCargaDePartido(Competencia competencia,ResultadoDTO resultado) {

		boolean aceptar = true;
			
		if (!competencia.getPermitirEmpates()){
			
			if (resultado.getResultadoLocal().equals(resultado.getResultadoVisitante())){
				aceptar = false;
			}
		}
		
		return aceptar;
	}
	
	private static ArrayList<Fecha> getFechas(int idCompetencia){
		
		return CompetenciaDAO.getFechas(idCompetencia);
		
	}
	
	
	public static String getTipoPuntuacion(CompetenciaDTO competenciaDTO) {

		return DAO_General.getTipoDePuntuacion(competenciaDTO.getUsuario(), competenciaDTO.getNombre());
				
	}	
	
	
	public static ArrayList<ArrayList<String>> generarCombinacionesFixture(int numeroParticipantes){
		
		ArrayList<ArrayList<String>> retorno = new ArrayList<ArrayList<String>>();
		
		int cantFechas = numeroParticipantes - 1;
		int vector2elemento0;
		int vector1elementoultimo;
		
		ArrayList<Integer> orden = new ArrayList<Integer>();
		ArrayList<Integer> vector1 = new ArrayList<Integer>();
		ArrayList<Integer> vector2 = new ArrayList<Integer>();
		
		for(int j = 0 ; j<numeroParticipantes/2;j++){
			vector1.add(j+1);			
		}
		for(int j = 0 ; j<numeroParticipantes/2;j++){
			vector2.add(j+1+numeroParticipantes/2);			
		}
		
		for(int i = 0; i<cantFechas;i++){
			
			ArrayList<String> fecha = new ArrayList<String>();
			
			orden.clear();
			
			for(int h=0;h<numeroParticipantes/2;h++){
				
				int n = (int)(Math.random()*((numeroParticipantes/2))-0.01);
							
				while(orden.contains(n)){
					
					n = (int)(Math.random()*((numeroParticipantes/2))-0.01);
					
				}
				
				orden.add(n);
											
			}
			
			
			if((i%2)==0){
				
				for(int m=0;m<numeroParticipantes/2;m++){
					
						fecha.add(vector1.get(orden.get(m))+" "+vector2.get(orden.get(m)));	
				}
			}
			
			else{
				
				for(int m=0;m<numeroParticipantes/2;m++){
									
					fecha.add(vector2.get(orden.get(m))+" "+vector1.get(orden.get(m)));
					
				}
				
			}
					
			vector2elemento0 = vector2.get(0);
			vector1elementoultimo = vector1.get(vector1.size()-1);
			
			for(int k=(numeroParticipantes/2)-1;k>1;k--){
				
				vector1.set(k, vector1.get(k-1));
				
			}
			
			
			for(int l=0;l<(numeroParticipantes/2)-1;l++){
				
				vector2.set(l, vector2.get(l+1));
				
			}
			
			vector1.set(1, vector2elemento0);
			vector2.set(vector2.size()-1, vector1elementoultimo);
	
			if((int)(Math.random()*2)>0.5){
				
				retorno.add(fecha);	
				
			}
			else{
				
				retorno.add(0,fecha);
				
			}
					
							
		}
					
		return retorno;
	}
	
	
	public static int getNumero(String secuencia, int posicion){
		
		int numeroRetorno;
		ArrayList<Integer> listaEspacios = new ArrayList<Integer>();
				
		listaEspacios.add(-1);
		
		for(int i=0;i<secuencia.length();i++){
			
			if(secuencia.charAt(i)==' '){
				listaEspacios.add(i);
	
			}
			else if( (i==secuencia.length()-1)){
				listaEspacios.add(i+1);
				
			}
		}
		
		numeroRetorno = Integer.parseInt(secuencia.substring(listaEspacios.get(posicion-1)+1,listaEspacios.get(posicion)));
		return numeroRetorno;
	}
	
	public static String detectarGanador(ResultadoDTO resultadoDTO){
		
		int local=0;
		int visitante=0;
		String retorno;
		
		ArrayList<SetsDTO> sets = resultadoDTO.getSets();
		for(int i=0;i<sets.size();i++){
			
			if(sets.get(i).getValorLocal()>sets.get(i).getValorVisitante()){
				local++;
			}
			else if(sets.get(i).getValorLocal()<sets.get(i).getValorVisitante()){
				visitante++;
			}
		}
		
		if(visitante>local){
			retorno = "Visitante";
		}
		else if(local>visitante){
			retorno = "Local";
		}
		else{
			retorno = "No disputado";
		}
		
		return retorno;
	}
	
}


